package com.jxmcloud.business.cut.util;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.DES;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.jxmcloud.business.cut.handler.UserEncryptionHandler;
import com.xlcloud.platform.util.DateUtil;
import com.xlcloud.platform.util.PublicUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


@Slf4j
public class MyTool {
    private static String DES_KEY = "CUT-SERVICE";
    // 添加静态缓存（需保证密钥固定）
    private static DES DES_INSTANCE = null;


    public static void makeNewIDes() {
        MyTool.DES_INSTANCE = SecureUtil.des(generateDesKey().getBytes());
    }


    /**
     * 从字符串生成 DES 密钥
     *
     * @return DES 密钥的字节数组
     */
    public static String generateDesKey() {
        try {
            // 使用 MD5 哈希算法将字符串转换为 16 字节的哈希值
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(MyTool.DES_KEY.getBytes(StandardCharsets.UTF_8));
            // 取前 8 字节作为 DES 密钥
            byte[] desKey = new byte[8];
            System.arraycopy(digest, 0, desKey, 0, 8);
            return new String(desKey);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    public static String desEncrypt(String data) {
        if (DES_INSTANCE == null) {
            // 生成新的 DES 实例
            DES_INSTANCE = SecureUtil.des(generateDesKey().getBytes());
        }
        // 改用预先生成的实例
        return DES_INSTANCE.encryptBase64(data);
    }

    public static String desDecrypt(String encryptedData) {
        String data = null;
        try {
            data = DES_INSTANCE.decryptStr(encryptedData);
        } catch (Exception e) {
            log.error("DES解密失败：{}", e.getMessage());
        }
        return data;
    }

    /**
     * 获取当前系统时间戳（秒）
     *
     * @param time
     * @return
     */
    public static Integer getCurrentTimeSecond(Long time) {
        if (time != null) {
            return (int) (time / 1000);
        } else {
            return (int) (System.currentTimeMillis() / 1000);
        }
    }

    /**
     * 生成用户 session key
     * 格式：uid_时间戳
     * 时间戳：秒级
     * 示例：1000_1725318680
     * @param uid
     * @return
     */
    public static String generateUserSessionKey(Integer uid) {
        return desEncrypt(uid + "_" + MyTool.getCurrentTimeSecond(null));
    }

    /**
     * 根据 session key 获取用户 uid
     * @param sessionKey
     * @return
     */
    public static String getUidBySessionKey(String sessionKey) {
        String data = desDecrypt(sessionKey);
        if (data == null) {
            return null;
        }
        return data.split("_")[0];
    }

    /**
     * 根据传递的参数 判断是否为 true
     * @param obj
     * @return
     */
    public static Boolean isTure(Object obj) {
        if (obj == null) {
            return false;
        } else if (obj instanceof Integer) {
            return (Integer) obj != 0;
        } else if (obj instanceof String) {
            return !StringUtils.isEmpty(obj);
        } else if (obj instanceof Boolean) {
            return (Boolean) obj;
        } else if (obj instanceof Long) {
            return (Long) obj!= 0L;
        } else if (obj instanceof Double) {
            return (Double) obj!= 0.0;
        } else if (obj instanceof Float) {
            return (Float) obj!= 0.0f;
        } else if (obj instanceof Short) {
            return (Short) obj!= 0;
        } else if (obj instanceof Byte) {
            return (Byte) obj!= 0;
        } else if (obj instanceof Character) {
            return (Character) obj!= 0;
        } else if (obj instanceof Number) {
            return ((Number) obj).intValue()!= 0;
        } else if (obj instanceof Collection) {
            return !((Collection<?>) obj).isEmpty();
        } else if (obj instanceof Map) {
            return !((Map<?,?>) obj).isEmpty();
        } else if (obj instanceof Object[]) {
            return ((Object[]) obj).length!= 0;
        }
        return false;
    }

    public static void main(String[] args)  {


        // ========================
//        // 多维 整数 数组
//        String d = "[[1,2],[3,4]]";
//        List<List<Integer>> list2d = JSON.parseArray(d, List.class).stream().map(item -> (List<Integer>) item).collect(Collectors.toList());
//        Integer[][] ttt = new Integer[list2d.size()][];
//        for (int i = 0; i < list2d.size(); i++) {
//            ttt[i] = list2d.get(i).toArray(new Integer[0]);
//        }
//
//        // 多维 字符串 数组
//        String str = "[[\"核实过后\",\"2\"],[\"3\",\"4\"]]";
//        List<List<String>> listStr2d = JSON.parseArray(str, List.class).stream().map(item -> (List<String>) item).collect(Collectors.toList());
//        String[][] sss = new String[listStr2d.size()][];
//        for (int i = 0; i < listStr2d.size(); i++) {
//            sss[i] = listStr2d.get(i).toArray(new String[0]);
//        }


//        Object  obj = JSON.parseObject(String.valueOf(str), String[][].class);

        // MyTool.makeNewIDes();
        // // u8eNOPy44lQ1nVQaJ9peL/1RezWY+HOfs4brtd8x03w=
        // // u8eNOPy44lQ1nVQaJ9peL/1RezWY+HOfs4brtd8x03w=
        // // String codeStr = "u8eNOPy44lQ1nVQaJ9peL%2F1RezWY%2BHOfs4brtd8x03w%3D";
        // String codeStr = "u8eNOPy44lQ1nVQaJ9peL/1RezWY+HOfs4brtd8x03w=";
        // try{
        //     codeStr = UserEncryptionHandler.generateInviteCode(105264L,2L);
        //     UserEncryptionHandler.getInviteCode(codeStr);
        //
        // } catch (UnsupportedEncodingException e) {
        //     log.error("URLDecoder.decode失败：{}", e.getMessage());
        // }



        return;
    }

    /**
     * 将时间字符串转换为时间戳（秒）
     *
     * @param timeStr
     * @return
     */
    public static Long convertTimeStrToLong(String timeStr) {
        return DateUtil.dateToTime(DateUtil.parseDate(timeStr));
    }


    /**
     * 将JSON格式的二维数组字符串转换为int二维数组
     *
     * @param arrayStr JSON格式的二维数组字符串，例如："[[1000,30102],[1,2]]"
     * @return int[][] 二维数组
     */
    public static int[][] convertTo2DArray(String arrayStr) {
        try {
            List<List<Integer>> list2D = JSON.parseArray(arrayStr, List.class).stream().map(item -> (List<Integer>) item).collect(Collectors.toList());

            int[][] result = new int[list2D.size()][];
            for (int i = 0; i < list2D.size(); i++) {
                List<Integer> innerList = list2D.get(i);
                result[i] = innerList.stream().mapToInt(Integer::intValue).toArray();
            }
            return result;
        } catch (Exception e) {
            log.error("二维数组转换失败：{}", e.getMessage());
            return new int[0][];
        }
    }

    /**
     * 使用Hutool将JSON数组字符串转换为二维数组（支持三维数组）
     *
     * @param arrayStr JSON格式的数组字符串，例如："[[[1000,30102],[1,2],[45,55]]]"
     * @return int[][][] 三维数组
     */
    public static int[][][] convertTo3DArray(String arrayStr) {
        try {
            JSONArray jsonArray = JSONUtil.parseArray(arrayStr);
            int[][][] result = new int[jsonArray.size()][][];

            for (int i = 0; i < jsonArray.size(); i++) {
                JSONArray secondLevel = jsonArray.getJSONArray(i);
                result[i] = new int[secondLevel.size()][];

                for (int j = 0; j < secondLevel.size(); j++) {
                    JSONArray thirdLevel = secondLevel.getJSONArray(j);
                    result[i][j] = thirdLevel.stream().mapToInt(v -> Integer.parseInt(v.toString())).toArray();
                }
            }
            return result;
        } catch (Exception e) {
            log.error("数组转换失败：{}", e.getMessage());
            return new int[0][][];
        }
    }

    /**
     * 将字符串 换为时间 戳 到秒
     *
     * @param time 示例： 2025-06-18 11:59:08
     * @return 时间戳 到秒 示例：1750219316
     */
    public static Long toTimeByString(String time) {
        PublicUtil.ifNullAndThrow(time, "入参不能为空");
        return DateUtil.dateToTime(DateUtil.parseDate(time));
    }

    /**
     * 将时间戳到秒 转换为时间
     *
     * @param s 秒 示例： 1750219148 10 位
     * @return 时间 示例：2025-06-18 11:59:08
     */
    public static String toTimeStrByLong(Long s) {
        PublicUtil.ifNullAndThrow(s, "入参不能为空");
        return DateUtil.formatDateTime(DateUtil.timeMillis2Date(s * 1000));
    }

    // 将 Date 转换为时间戳到秒
    public static Long toTimeByDate(java.util.Date date) {
        return DateUtil.dateToTime(date);
    }

    // 将时间戳到秒 转换为 Date
    public static java.util.Date toDateByLong(Long s) {
        return DateUtil.timeMillis2Date(s * 1000);
    }

    // 获取当前时间戳到秒
    public static Long getCurrentTime() {
        return new Date().getTime() / 1000;
    }

}
